GridPACK: exdc1.hpp Source File

00001 /*
00002  *    Copyright (c) 2013 Battelle Memorial Institute
00003  *    Licensed under modified BSD License. A copy of this license can be found
00004  *    in the LICENSE file in the top level directory of this distribution.
00005  */
00006 /*
00007  *  Created on: June 17, 2016
00008  *      Author: Bruce Palmer
00009  */
00010 #ifndef EXDC1_HPP
00011 #define EXDC1_HPP
00012 #include "gridpack/component/data_collection.hpp"
00013 #include "gridpack/parser/dictionary.hpp"
00014 #include "gridpack/utilities/string_utils.hpp"
00015 namespace gridpack {
00016 namespace parser {
00017 template <class _data_struct> class Exdc1Parser
00018 {
00019   public:
00020     /**
00021      * Constructor
00022      */
00023     explicit Exdc1Parser()
00024     {
00025     }
00026 
00027     /**
00028      * Destructor
00029      */
00030     virtual ~Exdc1Parser()
00031     {
00032     }
00033 
00034     /**
00035      * Extract data from _data_struct and store it in data collection object
00036      * @param data_struct data struct object
00037      * @param data data collection object
00038      * @param gen_id index of generator
00039      */
00040     void extract(_data_struct &data_struct,
00041         gridpack::component::DataCollection *data, int g_id)
00042     {
00043       double rval;
00044       bool bval;
00045       // HAS_EXCITER
00046       if (!data->getValue(HAS_EXCITER,&bval,g_id)) {
00047         data->addValue(HAS_EXCITER, true, g_id);
00048       } else {
00049         data->setValue(HAS_EXCITER, true, g_id);
00050       }
00051 
00052       // EXCITER_MODEL
00053       std::string stmp;
00054       if (!data->getValue(EXCITER_MODEL, &stmp, g_id)) {
00055         data->addValue(EXCITER_MODEL, data_struct.model, g_id);
00056       } else {
00057         data->setValue(EXCITER_MODEL, data_struct.model, g_id);
00058       }
00059 
00060       // EXCITER_TR
00061       if (!data->getValue(EXCITER_TR,&rval,g_id)) {
00062         data->addValue(EXCITER_TR, data_struct.ex_tr, g_id);
00063       } else {
00064         data->setValue(EXCITER_TR, data_struct.ex_tr, g_id);
00065       }
00066 
00067       // EXCITER_KA
00068       if (!data->getValue(EXCITER_KA,&rval,g_id)) {
00069         data->addValue(EXCITER_KA, data_struct.ex_ka, g_id);
00070       } else {
00071         data->setValue(EXCITER_KA, data_struct.ex_ka, g_id);
00072       }
00073 
00074       // EXCITER_TA
00075       if (!data->getValue(EXCITER_TA,&rval,g_id)) {
00076         data->addValue(EXCITER_TA, data_struct.ex_ta, g_id);
00077       } else {
00078         data->setValue(EXCITER_TA, data_struct.ex_ta, g_id);
00079       }
00080 
00081       // EXCITER_TB
00082       if (!data->getValue(EXCITER_TB,&rval,g_id)) {
00083         data->addValue(EXCITER_TB, data_struct.ex_tb, g_id);
00084       } else {
00085         data->setValue(EXCITER_TB, data_struct.ex_tb, g_id);
00086       }
00087 
00088       // EXCITER_TC
00089       if (!data->getValue(EXCITER_TC,&rval,g_id)) {
00090         data->addValue(EXCITER_TC, data_struct.ex_tc, g_id);
00091       } else {
00092         data->setValue(EXCITER_TC, data_struct.ex_tc, g_id);
00093       }
00094 
00095       // EXCITER_VRMAX
00096       if (!data->getValue(EXCITER_VRMAX,&rval,g_id)) {
00097         data->addValue(EXCITER_VRMAX, data_struct.vrmax, g_id);
00098       } else {
00099         data->setValue(EXCITER_VRMAX, data_struct.vrmax, g_id);
00100       }
00101 
00102       // EXCITER_VRMIN
00103       if (!data->getValue(EXCITER_VRMIN,&rval,g_id)) {
00104         data->addValue(EXCITER_VRMIN, data_struct.vrmin, g_id);
00105       } else {
00106         data->setValue(EXCITER_VRMIN, data_struct.vrmin, g_id);
00107       }
00108 
00109       // EXCITER_KE
00110       if (!data->getValue(EXCITER_KE,&rval,g_id)) {
00111         data->addValue(EXCITER_KE, data_struct.ex_ke, g_id);
00112       } else {
00113         data->setValue(EXCITER_KE, data_struct.ex_ke, g_id);
00114       }
00115 
00116       // EXCITER_TE
00117       if (!data->getValue(EXCITER_TE,&rval,g_id)) {
00118         data->addValue(EXCITER_TE, data_struct.ex_te, g_id);
00119       } else {
00120         data->setValue(EXCITER_TE, data_struct.ex_te, g_id);
00121       }
00122 
00123       // EXCITER_KF
00124       if (!data->getValue(EXCITER_KF,&rval,g_id)) {
00125         data->addValue(EXCITER_KF, data_struct.ex_kf, g_id);
00126       } else {
00127         data->setValue(EXCITER_KF, data_struct.ex_kf, g_id);
00128       }
00129 
00130       // EXCITER_TF1
00131       if (!data->getValue(EXCITER_TF1,&rval,g_id)) {
00132         data->addValue(EXCITER_TF1, data_struct.tf1, g_id);
00133       } else {
00134         data->setValue(EXCITER_TF1, data_struct.tf1, g_id);
00135       }
00136 
00137       // EXCITER_SWITCH
00138       if (!data->getValue(EXCITER_SWITCH,&rval,g_id)) {
00139         data->addValue(EXCITER_SWITCH, data_struct.rswitch, g_id);
00140       } else {
00141         data->setValue(EXCITER_SWITCH, data_struct.rswitch, g_id);
00142       }
00143 
00144       // EXCITER_E1
00145       if (!data->getValue(EXCITER_E1,&rval,g_id)) {
00146         data->addValue(EXCITER_E1, data_struct.ex_e1, g_id);
00147       } else {
00148         data->setValue(EXCITER_E1, data_struct.ex_e1, g_id);
00149       }
00150 
00151       // EXCITER_SE1
00152       if (!data->getValue(EXCITER_SE1,&rval,g_id)) {
00153         data->addValue(EXCITER_SE1, data_struct.se1, g_id);
00154       } else {
00155         data->setValue(EXCITER_SE1, data_struct.se1, g_id);
00156       }
00157 
00158       // EXCITER_E2
00159       if (!data->getValue(EXCITER_E2,&rval,g_id)) {
00160         data->addValue(EXCITER_E2, data_struct.ex_e2, g_id);
00161       } else {
00162         data->setValue(EXCITER_E2, data_struct.ex_e2, g_id);
00163       }
00164 
00165       // EXCITER_SE2
00166       if (!data->getValue(EXCITER_SE2,&rval,g_id)) {
00167         data->addValue(EXCITER_SE2, data_struct.se2, g_id);
00168       } else {
00169         data->setValue(EXCITER_SE2, data_struct.se2, g_id);
00170       }
00171     }
00172 
00173     /**
00174      * Parser list of strings and store results in data collection object
00175      * @param split_line list of tokens from .dyr file
00176      * @param data data collection object
00177      * @param gen_id index of generator
00178      */
00179     void parse(std::vector<std::string> &split_line,
00180         gridpack::component::DataCollection *data, int g_id)
00181     {
00182       double rval;
00183       bool bval;
00184       int nstr = split_line.size();
00185       // HAS_EXCITER
00186       if (!data->getValue(HAS_EXCITER,&bval,g_id)) {
00187         data->addValue(HAS_EXCITER, true, g_id);
00188       } else {
00189         data->setValue(HAS_EXCITER, true, g_id);
00190       }
00191 
00192       // EXCITER_MODEL
00193       std::string stmp, model;
00194       gridpack::utility::StringUtils util;
00195       model = util.trimQuotes(split_line[1]);
00196       util.toUpper(model);
00197       if (!data->getValue(EXCITER_MODEL,&stmp,g_id)) {
00198         data->addValue(EXCITER_MODEL, model.c_str(), g_id);
00199       } else {
00200         data->setValue(EXCITER_MODEL, model.c_str(), g_id);
00201       }
00202 
00203       // EXCITER_TR
00204       if (nstr > 3) {
00205         if (!data->getValue(EXCITER_TR,&rval,g_id)) {
00206           data->addValue(EXCITER_TR,
00207               atof(split_line[3].c_str()), g_id);
00208         } else {
00209           data->setValue(EXCITER_TR,
00210               atof(split_line[3].c_str()), g_id);
00211         }
00212       } 
00213 
00214       // EXCITER_KA
00215       if (nstr > 4) {
00216         if (!data->getValue(EXCITER_KA,&rval,g_id)) {
00217           data->addValue(EXCITER_KA,
00218               atof(split_line[4].c_str()), g_id);
00219         } else {
00220           data->setValue(EXCITER_KA,
00221               atof(split_line[4].c_str()), g_id);
00222         }
00223       } 
00224 
00225       // EXCITER_TA
00226       if (nstr > 5) {
00227         if (!data->getValue(EXCITER_TA,&rval,g_id)) {
00228           data->addValue(EXCITER_TA,
00229               atof(split_line[5].c_str()), g_id);
00230         } else {
00231           data->setValue(EXCITER_TA,
00232               atof(split_line[5].c_str()), g_id);
00233         }
00234       }
00235 
00236       // EXCITER_TB
00237       if (nstr > 6) {
00238         if (!data->getValue(EXCITER_TB,&rval,g_id)) {
00239           data->addValue(EXCITER_TB,
00240               atof(split_line[6].c_str()), g_id);
00241         } else {
00242           data->setValue(EXCITER_TB,
00243               atof(split_line[6].c_str()), g_id);
00244         }
00245       }
00246 
00247       // EXCITER_TC
00248       if (nstr > 7) {
00249         if (!data->getValue(EXCITER_TC,&rval,g_id)) {
00250           data->addValue(EXCITER_TC,
00251               atof(split_line[7].c_str()), g_id);
00252         } else {
00253           data->setValue(EXCITER_TC,
00254               atof(split_line[7].c_str()), g_id);
00255         }
00256       }
00257 
00258       // EXCITER_VRMAX
00259       if (nstr > 8) {
00260         if (!data->getValue(EXCITER_VRMAX,&rval,g_id)) {
00261           data->addValue(EXCITER_VRMAX,
00262               atof(split_line[8].c_str()), g_id);
00263         } else {
00264           data->setValue(EXCITER_VRMAX,
00265               atof(split_line[8].c_str()), g_id);
00266         }
00267       } 
00268 
00269       // EXCITER_VRMIN
00270       if (nstr > 9) {
00271         if (!data->getValue(EXCITER_VRMIN,&rval,g_id)) {
00272           data->addValue(EXCITER_VRMIN,
00273               atof(split_line[9].c_str()), g_id);
00274         } else {
00275           data->setValue(EXCITER_VRMIN,
00276               atof(split_line[9].c_str()), g_id);
00277         }
00278       } 
00279 
00280       // EXCITER_KE
00281       if (nstr > 10) {
00282         if (!data->getValue(EXCITER_KE,&rval,g_id)) {
00283           data->addValue(EXCITER_KE,
00284               atof(split_line[10].c_str()), g_id);
00285         } else {
00286           data->setValue(EXCITER_KE,
00287               atof(split_line[10].c_str()), g_id);
00288         }
00289       } 
00290 
00291       // EXCITER_TE
00292       if (nstr > 11) {
00293         if (!data->getValue(EXCITER_TE,&rval,g_id)) {
00294           data->addValue(EXCITER_TE,
00295               atof(split_line[11].c_str()), g_id);
00296         } else {
00297           data->setValue(EXCITER_TE,
00298               atof(split_line[11].c_str()), g_id);
00299         }
00300       } 
00301 
00302       // EXCITER_KF
00303       if (nstr > 12) {
00304         if (!data->getValue(EXCITER_KF,&rval,g_id)) {
00305           data->addValue(EXCITER_KF,
00306               atof(split_line[12].c_str()), g_id);
00307         } else {
00308           data->setValue(EXCITER_KF,
00309               atof(split_line[12].c_str()), g_id);
00310         }
00311       } 
00312 
00313       // EXCITER_TF1
00314       if (nstr > 13) {
00315         if (!data->getValue(EXCITER_TF1,&rval,g_id)) {
00316           data->addValue(EXCITER_TF1,
00317               atof(split_line[13].c_str()), g_id);
00318         } else {
00319           data->setValue(EXCITER_TF1,
00320               atof(split_line[13].c_str()), g_id);
00321         }
00322       } 
00323 
00324       // EXCITER_SWITCH
00325       if (nstr > 14) {
00326         if (!data->getValue(EXCITER_SWITCH,&rval,g_id)) {
00327           data->addValue(EXCITER_SWITCH,
00328               atof(split_line[14].c_str()), g_id);
00329         } else {
00330           data->setValue(EXCITER_SWITCH,
00331               atof(split_line[14].c_str()), g_id);
00332         }
00333       } 
00334 
00335       // EXCITER_E1
00336       if (nstr > 15) {
00337         if (!data->getValue(EXCITER_E1,&rval,g_id)) {
00338           data->addValue(EXCITER_E1,
00339               atof(split_line[15].c_str()), g_id);
00340         } else {
00341           data->setValue(EXCITER_E1,
00342               atof(split_line[15].c_str()), g_id);
00343         }
00344       } 
00345 
00346       // EXCITER_SE1
00347       if (nstr > 16) {
00348         if (!data->getValue(EXCITER_SE1,&rval,g_id)) {
00349           data->addValue(EXCITER_SE1,
00350               atof(split_line[16].c_str()), g_id);
00351         } else {
00352           data->setValue(EXCITER_SE1,
00353               atof(split_line[16].c_str()), g_id);
00354         }
00355       } 
00356 
00357       // EXCITER_E2
00358       if (nstr > 17) {
00359         if (!data->getValue(EXCITER_E2,&rval,g_id)) {
00360           data->addValue(EXCITER_E2,
00361               atof(split_line[17].c_str()), g_id);
00362         } else {
00363           data->setValue(EXCITER_E2,
00364               atof(split_line[17].c_str()), g_id);
00365         }
00366       } 
00367 
00368       // EXCITER_SE2
00369       if (nstr > 18) {
00370         if (!data->getValue(EXCITER_SE2,&rval,g_id)) {
00371           data->addValue(EXCITER_SE2,
00372               atof(split_line[18].c_str()), g_id);
00373         } else {
00374           data->setValue(EXCITER_SE2,
00375               atof(split_line[18].c_str()), g_id);
00376         }
00377       } 
00378     }
00379 
00380     /**
00381      * Parse list of strings store results in data_struct object
00382      * @param split_line list of tokens from .dyr file
00383      * @param data data struct that stores information from file
00384      */
00385     void store(std::vector<std::string> &split_line,_data_struct &data)
00386     {
00387       // EXCITER_BUSNUMBER               "I"                   integer
00388       int o_idx;
00389       o_idx = atoi(split_line[0].c_str());
00390       data.bus_id = o_idx;
00391 
00392       // Clean up 2 character tag for generator ID
00393       gridpack::utility::StringUtils util;
00394       std::string tag = util.clean2Char(split_line[2]);
00395       strcpy(data.gen_id, tag.c_str());
00396 
00397       std::string sval;
00398       double rval;
00399       int ival;
00400 
00401       sval = util.trimQuotes(split_line[1]);
00402       util.toUpper(sval);
00403 
00404       // EXCITER_MODEL              "MODEL"                  integer
00405       strcpy(data.model, sval.c_str());
00406 
00407       int nstr = split_line.size();
00408       // EXCITER_TR
00409       if (nstr > 3) {
00410         data.ex_tr = atof(split_line[3].c_str());
00411       }
00412 
00413       // EXCITER_KA
00414       if (nstr > 4) {
00415         data.ex_ka = atof(split_line[4].c_str());
00416       }
00417 
00418       // EXCITER_TA
00419       if (nstr > 5) {
00420         data.ex_ta = atof(split_line[5].c_str());
00421       }
00422 
00423       // EXCITER_TB
00424       if (nstr > 6) {
00425         data.ex_tb = atof(split_line[6].c_str());
00426       }
00427 
00428       // EXCITER_TC
00429       if (nstr > 7) {
00430         data.ex_tc = atof(split_line[7].c_str());
00431       }
00432 
00433       // EXCITER_VRMAX
00434       if (nstr > 8) {
00435         data.vrmax = atof(split_line[8].c_str());
00436       }
00437 
00438       // EXCITER_VRMIN
00439       if (nstr > 9) {
00440         data.vrmin = atof(split_line[9].c_str());
00441       }
00442 
00443       // EXCITER_KE
00444       if (nstr > 10) {
00445         data.ex_ke = atof(split_line[10].c_str());
00446       }
00447 
00448       // EXCITER_TE
00449       if (nstr > 11) {
00450         data.ex_te = atof(split_line[11].c_str());
00451       }
00452 
00453       // EXCITER_KF
00454       if (nstr > 12) {
00455         data.ex_kf = atof(split_line[12].c_str());
00456       }
00457 
00458       // EXCITER_TF1
00459       if (nstr > 13) {
00460         data.tf1 = atof(split_line[13].c_str());
00461       }
00462 
00463       // EXCITER_SWITCH
00464       if (nstr > 14) {
00465         data.rswitch = atof(split_line[14].c_str());
00466       }
00467 
00468       // EXCITER_E1
00469       if (nstr > 15) {
00470         data.ex_e1 = atof(split_line[15].c_str());
00471       }
00472 
00473       // EXCITER_SE1
00474       if (nstr > 16) {
00475         data.se1 = atof(split_line[16].c_str());
00476       }
00477 
00478       // EXCITER_E2
00479       if (nstr > 17) {
00480         data.ex_e2 = atof(split_line[17].c_str());
00481       }
00482 
00483       // EXCITER_SE2
00484       if (nstr > 18) {
00485         data.se2 = atof(split_line[18].c_str());
00486       }
00487     }
00488 };
00489 }  // parser
00490 }  // gridpack
00491 #endif